use anyhow::Result;
use axum_tonic_connection_pool::client::client_manager::{ClientManager, GrpcClient};
use axum_tonic_connection_pool::client::connection_pool::{ConnectionPool, ServiceConfig};
use axum_tonic_connection_pool::client::load_balancer::LoadBalancer;
use axum_tonic_connection_pool::web::web_server::{create_web_server, UserClient};
use std::sync::Arc;
use std::time::Duration;
use tonic::transport::Channel;
use tracing::{error, info, Level};
use tracing_subscriber;

pub mod user_service {
    tonic::include_proto!("user_service");
}

use crate::user_service::GetUserRequest;
use crate::user_service::user_service_client::UserServiceClient;

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt().with_max_level(Level::DEBUG).init();

    info!("🚀 启动gRPC客户端管理器示例...");

    let pool = ConnectionPool::new();
    let load_balancer = LoadBalancer::new();

    let user_config = ServiceConfig {
        name: "user_service".to_string(),
        endpoints: vec![
            "http://[::1]:50051".to_string(),
            "http://[::1]:50052".to_string(),
        ],
        max_connections: 10,
        connection_timeout: Duration::from_secs(1),
        request_timeout: Duration::from_secs(1),
    };

    let auth_config = ServiceConfig {
        name: "auth_service".to_string(),
        endpoints: vec![
            "http://[::1]:50051".to_string(),
            "http://[::1]:50052".to_string(),
        ],
        max_connections: 8,
        connection_timeout: Duration::from_secs(1),
        request_timeout: Duration::from_secs(1),
    };

    pool.register_service(user_config).await?;
    pool.register_service(auth_config).await?;

    pool.initialize_connections().await?;

    load_balancer
        .add_endpoints(
            "user_service",
            vec![
                "http://[::1]:50051".to_string(),
                "http://[::1]:50052".to_string(),
            ],
        )
        .await;

    let client_manager = ClientManager::new(pool, load_balancer);

    // 测试用户服务客户端
    // test_user_service(&client_manager)
    //     .await
    //     .expect("TODO: panic message");

    // 测试认证服务客户端
    // test_auth_service(&client_manager)
    //     .await
    //     .expect("TODO: panic message");

    // 测试重试机制
    // test_retry_mechanism(&client_manager)
    //     .await
    //     .expect("TODO: panic message");

    let client_manager = Arc::new(client_manager);

    let app = create_web_server(client_manager).await?;

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;

    println!("Server running on http://192.168.1.8:3000");
    axum::serve(listener, app).await?;

    Ok(())
}

// async fn test_user_service(manager: &ClientManager) -> Result<(), Box<dyn std::error::Error>> {
//     info!("🧪 测试用户服务客户端...");
//
//     // let mut user_client = manager.create_client_with_retry::<UserClient>("user_service").await?;
//     //
//     // let request = GetUserRequest { user_id: "wuzhijun".to_string(), };
//     //
//     // let response = user_client.0.get_user(request).await?;
//     //
//     // info!("Get User: {:?}", response.into_inner().user);
//
//     match manager.get_user_client().await {
//         Ok(mut client) => {
//             info!("✅ 成功创建用户服务客户端");
//             let response = client
//                 .get_user(GetUserRequest {
//                     user_id: "wuzhijun".to_string(),
//                 })
//                 .await?;
//             // 这里可以添加实际的gRPC调用
//             info!("Get User: {:?}", response.into_inner().user);
//         }
//         Err(e) => {
//             error!("❌ 创建用户服务客户端失败: {}", e);
//         }
//     }
//
//     // 测试带重试功能的客户端
//     match manager.get_user_client_with_retry().await {
//         Ok(mut client) => {
//             client
//                 .get_user(GetUserRequest {
//                     user_id: "wuzhijun".to_string(),
//                 })
//                 .await?;
//             info!("✅ 成功创建带重试的用户服务客户端");
//         }
//         Err(e) => {
//             error!("❌ 创建带重试的用户服务客户端失败: {}", e);
//         }
//     }
//
//     Ok(())
// }
//
// // async fn test_auth_service(manager: &ClientManager) -> Result<(), Box<dyn std::error::Error>> {
// //     info!("🔐 测试认证服务客户端...");
// //
// //     match manager.get_auth_client().await {
// //         Ok(client) => {
// //             info!("✅ 成功创建认证服务客户端");
// //         }
// //         Err(e) => {
// //             error!("❌ 创建认证服务客户端失败: {}", e);
// //         }
// //     }
// //
// //     match manager.get_auth_client_with_retry().await {
// //         Ok(client) => {
// //             info!("✅ 成功创建带重试的认证服务客户端");
// //         }
// //         Err(e) => {
// //             error!("❌ 创建带重试的认证服务客户端失败: {}", e);
// //         }
// //     }
// //
// //     Ok(())
// // }
//
// async fn test_retry_mechanism(manager: &ClientManager) -> Result<(), Box<dyn std::error::Error>> {
//     info!("🔄 测试重试机制...");
//
//     // 模拟网络错误场景
//     info!("📡 模拟网络波动场景...");
//
//     // 这里可以添加模拟网络错误的重试测试
//
//     Ok(())
// }
